home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / turbo_tk.arc / IOTTT.PAS < prev    next >
Pascal/Delphi Source File  |  1988-02-01  |  21KB  |  639 lines
  1. {S-,R-,V-,D-,T-}
  2. {\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\}
  3. {         TechnoJocks Turbo Toolkit v4.00            Released: Feb 1, 1988    }
  4. {                                                                             }
  5. {         Module: IOTTT   --   screen input/editing routines                  }
  6. {                                                                             }
  7. {                       Copyright R. D. Ainsbury (c) 1986                     }
  8. {\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\}
  9.  
  10. unit IOTTT;
  11.  
  12. interface
  13.  
  14. uses CRT,FastTTT,DOS,WinTTT,KeyTTT;
  15.  
  16. CONST
  17. MaxInputFields = 40;       {alter as necessary}
  18.  
  19. TYPE
  20. Str_Field_Defn = record
  21.                       Upfield   : byte;
  22.                       Downfield : byte;
  23.                       Leftfield : byte;
  24.                       Rightfield: byte;
  25.                       X         : byte;
  26.                       Y         : byte;
  27.                       InString  : ^string;
  28.                       StrLength : byte;
  29.                       Format    : string;
  30.                       Message   : string;
  31.                       MsgX      : byte;
  32.                       MsgY      : byte;
  33.                       CursorX   : byte;
  34.                       CursorInit: byte;
  35.                       StrLocX   : byte;
  36.                 end;
  37. Str_Field_Ptr = ^Str_Field_Defn;
  38. InputZone = record
  39.              HiF  : byte;
  40.              HiB  : byte;
  41.              LoF  : byte;
  42.              LoB  : byte;
  43.              MsgF : byte;
  44.              MsgB : byte;
  45.              TotalFields: byte;
  46.              CurrentField : byte;
  47.              IOEsc : boolean;
  48.              IO_FieldsSet : boolean;
  49.              Displayed   : boolean;
  50.              IO_Beepon : boolean;
  51.              IO_Putunderline : boolean;
  52.              IO_Insert : boolean;
  53.             end;
  54. CONST
  55.    IO_Settings : InputZone= (HiF:white;
  56.                              HiB:blue;
  57.                              LoF:blue;
  58.                              LoB:lightgray;
  59.                              MsgF:yellow;
  60.                              MsgB:red;
  61.                              TotalFields:MaxInputFields;
  62.                              CurrentField : 1;
  63.                              IOEsc : false;
  64.                              IO_FieldsSet : false;
  65.                              Displayed    : false;
  66.                              IO_BeepOn    : true;
  67.                              IO_PutUnderline: true;
  68.                              IO_Insert : false);
  69.  
  70. var
  71.   FieldDefn : array[0..MaxInputFields] of Str_Field_Ptr;
  72.   IO_UserHook : pointer;
  73.  
  74. Procedure IO_Setfields(No_of_fields:byte);
  75. Procedure IO_SetColors(HiFore,Hiback,LoFore,LoBack,MsgFore,MsgBack:byte);
  76. Procedure IO_DefineMsg(DefID,DefX,DefY : byte; DefString : string);
  77. Procedure IO_DefineStr(DefID,DefU,DefD,DefL,DefR,DefX,DefY:byte;
  78.                          Var DefString : string;
  79.                          DefFormat : string);
  80. Procedure IO_DisplayFields;
  81. Procedure IO_AllowEsc(OK:boolean);
  82. Procedure IO_SoundBeeper(OK:boolean);
  83. Procedure IO_ResetFields;
  84. Procedure IO_Edit(var Return_code : integer);
  85.  
  86. implementation
  87.  
  88. Const
  89.    FmtChars  : set of char = ['!','#','@','*'];
  90.    IOUp       = #200;
  91.    IODown     = #208;
  92.    IORight    = #205;
  93.    IOLeft     = #203;
  94.    IODel      = #211;
  95.    IOTotErase = #146;    {Alt-E}
  96.    IOErase    = #160;    {Alt-D}
  97.    IOFinish   = #207;    {End}   {maybe change to F10}
  98.    IOEsc      = #27;
  99.    IOTab      = #9;
  100.    IOShiftTab = #143;
  101.    IOEnter    = #13;
  102.    IOIns      = #210;
  103.    IOBackSp   = #8;
  104.    IORightFld = #244;
  105.    IOLeftFld  = #243;
  106.    IOHelp     = #187;
  107.    
  108. Procedure CallFromIO(Ch: char; FieldID:integer;var ReturnStr:string);
  109.           Inline($FF/$1E/IO_UserHook);
  110.  
  111. Function Int_to_Str(Number:Integer):string;
  112. var Temp : string;
  113. begin
  114.     Str(Number,temp);
  115.     Int_to_Str := temp;
  116. end;
  117.  
  118. function Real_to_str(Number:real;Decimals:byte):string;
  119. var Temp : string;
  120. begin
  121.     Str(Number:20:Decimals,Temp);
  122.     repeat
  123.          If copy(Temp,1,1) = ' ' then delete(Temp,1,1);
  124.     until copy(temp,1,1) <> ' ';
  125.     Real_to_Str := Temp;
  126. end;
  127.  
  128. Function  Str_to_Int(Str:string):integer;
  129. var temp,code : integer;
  130. begin
  131.     If length(Str) = 0 then
  132.        Str_to_Int := 0
  133.     else
  134.     begin
  135.        val(Str,temp,code);
  136.        if code = 0 then
  137.           Str_to_Int := temp
  138.        else
  139.           Str_to_Int := 0;
  140.     end;
  141. end;
  142.  
  143. Procedure IOError(Code:byte;value:real);    {fatal error -- msg and halt}
  144. var Message:string;
  145. begin
  146.     {Clrscr;}
  147.     Case Code of
  148.     1 : Message := 'Fatal Error 1: Invalid value of '+Real_to_Str(value,0)
  149.                    +' in IO_SetFields with a MaxInputFields of '
  150.                    +Real_to_Str(MaxInputFields,0);
  151.     2 : Message := 'Fatal Error 2 : Insufficient Memory on Heap. Available '
  152.                    +Real_to_Str(MaxAvail,0)+'. Required '
  153.                    +Real_to_Str(value,0);
  154.     3 : Message := 'Fatal Error 3 : Define IO_Setfields before IO_DefineStr';
  155.     4 : Message := 'Fatal Error 4 : IO_DefineStr ID: '
  156.                    +Real_to_Str(value,0)+' out of range';
  157.     5 : Message := 'Fatal Error 5 : Invalid exit field defined in IO_DefinStr ID: '
  158.                    +Real_to_Str(value,0);
  159.     6 : message := 'Fatal Error 6 : Invalid X or Y value defined in IO_DefineStr ID: '
  160.                    +Real_to_Str(value,0);
  161.     7 : Message := 'Fatal Error 7 : Define IO_Setfields before IO_DefineMsg';
  162.     8 : Message := 'Fatal Error 8 : IO_DefineMsg ID: '+Real_to_Str(value,0)
  163.                    +' out of range';
  164.     9 : message := 'Fatal Error 9 : Invalid X or Y value defined in IO_DefineMsg ID: '
  165.                    +Real_to_Str(value,0);
  166.     10 : Message := 'Fatal Error 10 : Only use IO_ResetFields after IO_Setfields';
  167.     11 : Message := 'Fatal Error 11 : IO_Setfields already operative,'
  168.                     +' reset with IO_Resetfields';
  169.     else Message := 'Aborting';
  170.     end; {case}
  171.     WriteAT(1,12,black,lightgray,Message);
  172.     Repeat Until keypressed;
  173.     Halt;
  174. end;    {proc IOError}
  175.  
  176. Procedure Ding;
  177. begin
  178.     If IO_Settings.IO_BeepOn then
  179.        sound(750);delay(150);nosound;
  180. end;    {proc Ding}
  181.  
  182. Procedure InsertMode;       {change cursor style when in insert mode}
  183. begin
  184.     IO_Settings.IO_Insert := not IO_Settings.IO_Insert;
  185.     If IO_Settings.IO_Insert then
  186.        HalfCursor
  187.     else
  188.        OnCursor;
  189. end;
  190.  
  191. Procedure IO_Setfields(No_of_fields:byte);
  192. var
  193.   I:integer;
  194.   Room_needed : integer;
  195. begin
  196.     If IO_Settings.IO_FieldsSet then IOError(11,0);       {already set}
  197.     If No_of_Fields in [1..MaxInputFields] then
  198.     begin
  199.         Room_needed := sizeof(FieldDefn[0]^);
  200.         For I := 0 to No_of_fields do
  201.         begin
  202.             If MaxAvail >= Room_needed then
  203.             begin
  204.                 GetMem(FieldDefn[I],Room_Needed);
  205.                 with FieldDefn[I]^ do
  206.                 begin
  207.                     Upfield     := 0;
  208.                     Downfield   := 0;
  209.                     Leftfield   := 0;
  210.                     Rightfield  := 0;
  211.                     X           := 0;
  212.                     Y           := 0;
  213.                     StrLength   := 0;
  214.                     Format      := '';
  215.                     Message     := '';
  216.                     MsgX        := 81;     {zero means auto-center}
  217.                     MsgY        := 0;
  218.                     CursorX     := 0;
  219.                     CursorInit  := 0;
  220.                     StrLocX     := 1;
  221.                 end;   {With}
  222.             end
  223.             else  {not enough heap space}
  224.                 IOError(2,Room_needed); {end MemAvail If clause}
  225.         end;
  226.         IO_Settings.TotalFields := No_of_Fields;
  227.         IO_Settings.IO_FieldsSet := true;
  228.     end
  229.     else  {Invalid No_of_fields}
  230.        IOError(1,No_of_fields);
  231. end;  {Proc IO_SetFields}
  232.  
  233. Procedure IO_SetColors(HiFore,Hiback,LoFore,LoBack,MsgFore,MsgBack:byte);
  234. begin
  235.     With IO_Settings do
  236.     begin
  237.         HiF := HiFore;
  238.         HiB := HiBack;
  239.         LoF := LoFore;
  240.         LoB := LoBack;
  241.         MsgF := MsgFore;
  242.         MsgB := MsgBack;
  243.     end;
  244. end;    {Proc IO_SetColors}
  245.  
  246. Procedure IO_DefineMsg(DefID,DefX,DefY : byte; DefString : string);
  247. begin
  248.     If not IO_Settings.IO_FieldsSet then IOError(7,0);
  249.     If (DefID < 1) or (DefID > IO_Settings.TotalFields) then IOError(8,DefID);
  250.     If (DefX < 0) or (DefX > 80) or (DefY < 1) or (DefY > 25) then IOError(9,DefID);
  251.     With FieldDefn[Defid]^ do
  252.     begin
  253.         MsgX := DefX;
  254.         MsgY := DefY;
  255.         Message := DefString;
  256.     end;
  257. end;  {proc IO_DefineMsg}
  258.  
  259. Procedure IO_DefineStr(DefID,DefU,DefD,DefL,DefR,DefX,DefY:byte;
  260.                          Var DefString : string;
  261.                          DefFormat : string);
  262.  
  263.              Function Max_string_length : byte;
  264.              var I,Counter : byte;
  265.              begin
  266.                  Counter := 0;
  267.                  For I := 1 to length(DefFormat) do
  268.                      if (DefFormat[I] in FmtChars) then
  269.                         Counter := succ(counter);
  270.                  Max_string_length := Counter;
  271.              end;  {sub func Max_String_Length}
  272.  
  273.              Function  Pos_of_First_Input_Char: byte;
  274.              var Counter : byte;
  275.              begin
  276.                  Counter := 0;
  277.                  Repeat
  278.                       Counter := succ(Counter);
  279.                  Until DefFormat[Counter] in FmtChars;
  280.                  Pos_of_First_Input_Char := FieldDefn[DefID]^.X + counter - 1;
  281.              end;
  282. begin
  283.     If not IO_Settings.IO_FieldsSet then IOError(3,0);
  284.     If (DefID < 1) or (DefID>IO_Settings.TotalFields) then IOError(4,Defid);
  285.     If  (DefU < 0)  or (DefU > IO_Settings.TotalFields)
  286.     or (DefD < 0)  or (DefD > IO_Settings.TotalFields)
  287.     or (DefL < 0)  or (DefL > IO_Settings.TotalFields)
  288.     or (DefR < 0)  or (DefR > IO_Settings.TotalFields)
  289.                        then             IOError(5,Defid);
  290.     If  (DefX < 1) or (DefX > 80)
  291.     or (DefY < 1) or (DefY > 25)
  292.                        then             IOError(6,Defid);
  293.     With FieldDefn[DefID]^ do
  294.     begin
  295.         Upfield    := DefU;
  296.         Downfield  := DefD;
  297.         Leftfield  := DefL;
  298.         Rightfield := DefR;
  299.         X          := DefX;
  300.         Y          := DefY;
  301.         InString   := ptr(seg(defstring),ofs(defstring));
  302.         StrLength  := Max_String_length;
  303.         Format     := DefFormat;
  304.         CursorX    := Pos_of_First_Input_Char;
  305.         CursorInit := Pos_of_First_Input_Char;
  306.     end;
  307. end; {proc IO_DefineStr}
  308.  
  309. Function IO_FmtStr(Str,Fmt:string):string;
  310. var
  311. TempStr : string;
  312. I,J : byte;
  313. begin
  314.     J := 0;
  315.     For I := 1 to length(Fmt) do
  316.     begin
  317.         If not (Fmt[I] in FmtChars) then
  318.         begin
  319.             TempStr[I] := Fmt[I] ;  {force any none format charcters into string}
  320.              J := succ(J);
  321.         end
  322.         else    {format character}
  323.         begin
  324.             If I - J <= length(Str) then
  325.                TempStr[I] := Str[I - J]
  326.             else
  327.                TempStr[I] := '_';    {pad with underlines}
  328.         end;
  329.     end;
  330.     TempStr[0] := char(length(Fmt));  {set initial byte to string length}
  331.     IO_FmtStr := Tempstr;
  332. end;  {Func FmtStr}
  333.  
  334. Procedure Hilight(ID:byte);      {display cell in bright colors}
  335. begin
  336.     with FieldDefn[ID]^ do
  337.          WriteAT(X,Y,IO_Settings.HiF,IO_Settings.HiB,
  338.                  IO_FmtStr(InString^,Format));
  339. end;
  340.  
  341. Procedure LoLight(ID:byte);      {display cell in dim colors}
  342. begin
  343.     with FieldDefn[ID]^ do
  344.          WriteAT(X,Y,IO_Settings.LoF,IO_Settings.LoB,
  345.                  IO_FmtStr(InString^,Format));
  346. end;
  347.  
  348. Procedure IO_DisplayFields;
  349. var I : integer;
  350. begin
  351.     For I :=  1 to IO_Settings.TotalFields do
  352.         LoLight(I);
  353.     IO_Settings.Displayed  := true;
  354. end;
  355.  
  356. Procedure IO_AllowEsc(OK:boolean);
  357. begin
  358.     IO_Settings.IOEsc := OK;
  359. end;    {proc IO_AllowEsc}
  360.  
  361. Procedure IO_SoundBeeper(OK:boolean);
  362. begin
  363.     IO_Settings.IO_BeepOn := OK;
  364. end;    {proc IO_SoundBeeper}
  365.  
  366. Procedure IO_ResetFields;
  367. var I : integer;
  368. begin
  369.     If not IO_Settings.IO_FieldsSet then IOError(10,0);
  370.     IO_UserHook := nil;
  371.     For I := 0 to IO_Settings.TotalFields do
  372.         FreeMem(FieldDefn[I],sizeof(FieldDefn[I]^));
  373.     With IO_Settings do
  374.     begin
  375.         IO_FieldsSet := false;
  376.         TotalFields := 0;
  377.         IOEsc := false;
  378.         Displayed := false;
  379.         IO_Beepon := true;
  380.         IO_PutUnderline := true;
  381.         IO_Insert := false;
  382.         CurrentField := 1;
  383.     end; {with}
  384.     IO_UserHook  := nil;
  385. end; { proc IO_ResetFields }
  386.  
  387. {
  388. ****************************
  389. *      Main Procedure      *
  390. ****************************
  391. }
  392.  
  393. Procedure IO_Edit(var Return_code : integer);
  394. const
  395.     finished : boolean = false;
  396. var
  397.     OldLine : array[1..160] of byte;
  398.  
  399.     Procedure DisplayMessage(ID:byte);
  400.     begin
  401.         With FieldDefn[ID]^ do
  402.         begin
  403.             If MsgX = 0 then   {Center the message}
  404.                MsgX := (80 - length(Message)) div 2;
  405.             PartSave(MsgX,MsgY,MsgX+length(Message),MsgY,OldLine);
  406.             WriteAT(MsgX,MsgY,IO_Settings.MsgF,IO_Settings.MsgB,Message);
  407.         end; {sub sub proc DisplayMessage}
  408.     end;
  409.  
  410.     Procedure RemoveMessage(ID:byte);
  411.     var I,LocC : integer;
  412.     begin
  413.         With FieldDefn[ID]^ do
  414.              PartRestore(MsgX,MsgY,MsgX+length(Message),MsgY,OldLine);
  415.     end; {sub sub proc RemoveMessage}
  416.  
  417.   Procedure Change_Fields(ID:byte);
  418.   begin
  419.       LoLight(IO_Settings.CurrentField);
  420.       If FieldDefn[IO_Settings.CurrentField]^.MsgX <= 80 then
  421.          RemoveMessage(IO_Settings.CurrentField);
  422.       If ID = 0 then
  423.       begin
  424.           Finished := true;
  425.           Return_Code := 0;
  426.       end
  427.       else
  428.       begin
  429.           IO_Settings.CurrentField := ID;
  430.           If IO_Settings.IO_Insert = true then      {switch insert off}
  431.              InsertMode;
  432.           HiLight(IO_Settings.CurrentField);
  433.          If FieldDefn[IO_Settings.CurrentField]^.MsgX <= 80 then
  434.             DisplayMessage(IO_Settings.CurrentField);
  435.          With FieldDefn[IO_Settings.CurrentField]^ do
  436.               GotoXY(CursorX,Y);
  437.          Ding;
  438.      end;  {If ID = 0};
  439.   end;  {proc change fields}
  440.  
  441.   Procedure Erase_Field(ID:byte);
  442.   begin
  443.       with FieldDefn[ID]^ do
  444.       begin
  445.           Instring^ := '';
  446.           CursorX   := CursorInit;
  447.           StrLocX := 1;
  448.       end;
  449.   end;
  450.  
  451.   Procedure Global_Erase;
  452.   var I : integer;
  453.   begin
  454.   {MayBe paint an are you sure window}
  455.       For I :=  1 to IO_Settings.TotalFields do
  456.           Erase_Field(I);
  457.       IO_DisplayFields;
  458.       IO_Settings.CurrentField := 1;
  459.   end;
  460.  
  461.   Procedure Cursor_Right;
  462.   begin
  463.       With FieldDefn[IO_Settings.CurrentField]^ do
  464.       begin
  465.           If (StrLocX <= length(InString^)) and (StrLocX < StrLength) then
  466.           begin
  467.               StrLocX := succ(StrLocX);
  468.               Repeat
  469.                    CursorX := succ(CursorX);
  470.               Until Format[CursorX + 1 - X] in FmtChars;
  471.           end;
  472.           GotoXY(CursorX,Y);
  473.       end; {with}
  474.   end; {Proc Cursor_Right}
  475.  
  476.  
  477.   Procedure Cursor_Left;
  478.   begin
  479.       With FieldDefn[IO_Settings.CurrentField]^ do
  480.       begin
  481.           If StrLocX > 1 then
  482.           begin
  483.               StrLocX := pred(StrLocX);
  484.               Repeat
  485.                    CursorX := CursorX - 1;
  486.               Until Format[CursorX + 1 - X] in FmtChars;
  487.           end;
  488.       end;  {with}
  489.   end;  {Proc Cursor_left}
  490.  
  491.   Procedure Delete_Char;
  492.   var
  493.     Temp : boolean;
  494.     I : integer;
  495.   begin
  496.       Temp := false;                                 {insert a space if there are}
  497.       with FieldDefn[IO_Settings.CurrentField]^ do   {non format characters}
  498.       begin
  499.           For I := 1 to length(Format) do
  500.               If not (Format[I] in FmtChars) then
  501.                  Temp := true;
  502.           Delete(InString^,StrLocX,1);
  503.           If Temp = true then
  504.              Insert(' ',Instring^,StrlocX);
  505.       end;  {with}
  506.   end;  {Delete_Chars}
  507.  
  508.   Procedure Backspaced;
  509.   begin
  510.       with FieldDefn[IO_Settings.CurrentField]^ do
  511.       begin
  512.           If StrLocX > 1 then
  513.           begin
  514.               Cursor_Left;
  515.               Delete(InString^,StrLocX,1);
  516.           end;
  517.       end;  {with}
  518.   end;  { Proc Backspaced }
  519.  
  520.   Procedure Activity;
  521.   var
  522.     K : char;
  523.     ReturnStr: string;
  524.     Prior_CursorX : byte;
  525.   begin
  526.       K := Getkey;
  527.  
  528.       If IO_UserHook <> nil then
  529.       begin
  530.          ReturnStr := '';
  531.          CallFromIO(K,IO_Settings.CurrentField,ReturnStr);
  532.          If ReturnStr <> '' then
  533.             with FieldDefn[IO_Settings.CurrentField]^ do
  534.             begin
  535.                 InString^ := copy(ReturnStr,1,StrLength);
  536.                 CursorX := X;
  537.                 StrLocX := 1;
  538.                 Repeat
  539.                      Prior_CursorX := CursorX;
  540.                      Cursor_Right;
  541.                 Until CursorX = Prior_CursorX;
  542.            end;
  543.       end;
  544.       Case K of
  545.       #132,   {mouse right but}
  546.       IOEsc : If IO_Settings.IOEsc then
  547.               begin
  548.                   Finished := true;
  549.                   Return_Code := 1;
  550.               end
  551.               else Ding;
  552.       IOFinish : begin
  553.                      Finished := true;
  554.                      Return_code := 0;
  555.                  end;
  556.       #32..#126 :  with FieldDefn[IO_settings.CurrentField]^ do
  557.                    begin
  558.                        If Format[CursorX - X + 1] = '!' then K := upcase(K);
  559.                        If ((K in ['0'..'9','.','-','e','E']) and (Format[CursorX - X + 1] = '#'))
  560.                        or ((K in ['a'..'z','A'..'Z',' ',',','.',';',':']) and
  561.                                                  (Format[CursorX - X + 1] = '@'))
  562.                        or (Format[CursorX - X + 1] = '*')
  563.                        or (Format[CursorX - X + 1] = '!') then
  564.                        begin
  565.                            If IO_Settings.IO_Insert then          {in insert mode}
  566.                            begin
  567.                                If length(Instring^) < StrLength then
  568.                                begin
  569.                                    Insert(K,Instring^,StrLocX);
  570.                                    Cursor_Right;
  571.                                end
  572.                                else Ding;
  573.                            end
  574.                            else                        {in overlay mode}
  575.                            begin
  576.                                Delete(Instring^,StrLocX,1);
  577.                                Insert(K,Instring^,StrLocX);
  578.                                Cursor_Right;
  579.                            end; {If insert}
  580.                        end
  581.                        else Ding; {end if K in statement}
  582.                    end;  {with}
  583.       #133,    {mouse left but}
  584.       #131,      {mouse right}
  585.       IORightFld,
  586.       IOTab,
  587.       IOEnter : Change_Fields(FieldDefn[IO_Settings.CurrentField]^.RightField);
  588.  
  589.       #130,      {mouse left}
  590.       IOLeftFld,
  591.       IOShiftTab :Change_Fields(FieldDefn[IO_Settings.CurrentField]^.LeftField);
  592.  
  593.       IOBackSp : Backspaced;
  594.  
  595.       IODel    : Delete_Char;
  596.  
  597.       IOLeft   : Cursor_Left;
  598.  
  599.       IORight  : Cursor_Right;
  600.  
  601.       #128,    {mouse up}
  602.       IOUp     : Change_Fields(FieldDefn[IO_Settings.CurrentField]^.UpField);
  603.  
  604.       #129,    {mouse down}
  605.       IODown   : Change_Fields(FieldDefn[IO_Settings.CurrentField]^.DownField);
  606.  
  607.       IOErase    : Erase_Field(IO_Settings.CurrentField);
  608.  
  609.       IOTotErase : Global_Erase;
  610.  
  611.       IOIns      : InsertMode;
  612.  
  613.  
  614.       else Ding;
  615.       end; {case}
  616.       HiLight(IO_Settings.CurrentField);
  617.       With FieldDefn[IO_Settings.CurrentField]^ do
  618.       GotoXY(CursorX,Y);
  619.   end;    {Proc Activity}
  620.  
  621.  
  622. begin   {IO_Edit}
  623.     If IO_Settings.Displayed = false then IO_DisplayFields;
  624.     Hilight(IO_Settings.CurrentField);
  625.     If FieldDefn[IO_Settings.CurrentField]^.MsgX <= 80 then
  626.        DisplayMessage(IO_Settings.CurrentField);
  627.     GotoXY(FieldDefn[IO_Settings.CurrentField]^.CursorX,
  628.            FieldDefn[IO_Settings.CurrentField]^.Y);
  629.     Finished := false;
  630.     repeat
  631.          Activity
  632.     until Finished;
  633. end;   {IO_Edit}
  634.  
  635. begin  {Initial Auto proc}
  636.     IO_UserHook := nil;
  637.     If BaseOfScreen = $B000 then
  638.        IO_SetColors(black,lightgray,lightgray,black,white,black);
  639. end.